﻿package CutLoad
{
	import CutLoad.*;
	import CutLoad.components.CButton;
	import CutLoad.components.CPopup;
	import CutLoad.components.CPopupSpring;
	import CutLoad.components.CRender;
	import CutLoad.components.CTextField;
	import CutLoad.components.CTextInput;
	import CutLoad.components.CTip;
	import CutLoad.components.Skin;
	import CutLoad.components.container.Container;
	import CutLoad.components.container.ContainerH;
	import CutLoad.components.container.ContainerV;
	import CutLoad.components.loadbar.ILoadBar;
	import CutLoad.components.loadbar.Loadbar;
	import CutLoad.components.loadbar.LoadbarForCutLoad;
	import CutLoad.components.window.CAlert;
	import CutLoad.components.window.CWait;
	import CutLoad.components.window.CWindow;
	import CutLoad.components.window.CWindowTextArea;
	import CutLoad.cookies.*;
	
	import flash.display.BitmapData;
	import flash.display.InteractiveObject;
	import flash.display.Loader;
	import flash.display.LoaderInfo;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageDisplayState;
	import flash.display.StageScaleMode;
	import flash.events.ContextMenuEvent;
	import flash.events.Event;
	import flash.events.IOErrorEvent;
	import flash.events.MouseEvent;
	import flash.events.ProgressEvent;
	import flash.events.SecurityErrorEvent;
	import flash.net.LocalConnection;
	import flash.net.URLRequest;
	import flash.system.ApplicationDomain;
	import flash.system.LoaderContext;
	import flash.text.TextFormat;
	import flash.ui.ContextMenu;
	import flash.ui.ContextMenuItem;

	/**
	 * <p>程序入口类</p>
	 * 主要完成以下功能
	 * <ul>
	 * <li>分层</li>
	 * <li>弹出管理</li>
	 * <li>画面尺寸改变时，上下左右居中对齐始终不变。</li>
	 * <li>画面尺寸改变时，通知注册的元件进行相应的处理。</li>
	 * <li>分块加载的管理</li>
	 * </ul>
	 * <p>关于分层的顺序:请参考CutLoad.getLayer(...)说明</p>
	 * <p>关于加载的进度条:加载的进度条有两类：应用主程序本身的加载进度条和加载模块swf文件的进度条，分别可以通过：setLoadBarMainApp()和setLoadBar()设置。需要注意的是这个进度条必须是Base的子类并且实现CutLoad.components.ILoadBar接口</p>
	 * @author smallerbird mail:smallerbird@gmail.com  site:www.mkigm.com QQ群:49983196
	 * 
	 */	
	public class CutLoad extends MovieClip  implements IBase
	{
		/**
		 * 版本号,格式说明:[版本号.最后修改的年月日]
		 */		
		public static var VERSION:String="CutLoad v0.20120328";
		//debug保存
		protected static var DEBUG_MESSAGE:Array=new Array();
		//保留言几条调试信息
		protected static var DEBUG_MESSAGE_LENGTH:Number=8;
		protected static var DEBUG_JS:Number=0;
		protected static var DEBUG_PASSWORD:String="";
		//无效的数字
		public static const NULLNO:Number=-100000;
		/**
		 * 提示框管理
		 */		
		protected var tipManagement:CTipManagement=null;
		//当显示的提示框不是相对场景的坐标时用到的提标框管理 	
		protected var tipNoStageManagement:CTipManagement=null;
		//水印
		protected var spWatermark:Sprite
		//弹出管理器
		protected var Popup:CPopup;
		//最顶
		protected var spTop:Sprite=null;
		//放置相对对齐的容器
		protected var containerAlign:Container;
		//放置画面的
		protected var spFrameParent:Sprite;
		//整个背景
		protected var spBak:CRender;
		//入口文件
		protected  var mainSwfName:String="";	
		//需要设置场景的尺寸
		protected var arrResize:Array;
		//当尺寸发生改变时，要运行的方法
		protected var funResizeDo:Function=null;
		//是否当场景的尺寸改变时，自动设置场景当前的宽高
		protected var isAutoResizeWH:Boolean=true;
		//加载-------------------------------------------------------------------------------start
		protected var loadBar:ILoadBar=null;
		protected var clone_loadBar:ILoadBar=null;
		//要加载的库的列表
		protected var arrLibList:Array;
		//当前加的库的下标
		protected var arrLibListIndex:Number=0;
		//是否加载了入口文件。
		protected var isLoadMain:Boolean=false
		//当前加载的swf文件名
		protected var nowLoadSwfName:String="";
		//是否加载cutload库文件lib.swf
		protected var isLoadedLib:Number=0;
		//当前加载的画面
		protected var currentModule:ModuleBase=null;
		//不用cutload的ui
		protected var isNotUseUi:Boolean=false;
		//为模块文件保存的变量
		protected var moduleData:CArray;
		protected var currentModuleData:ModuleData=null;
		protected var winDebug:CWindowTextArea=null;
		protected var cwindpwd:CWindow=null;
		//主程序是否加载完成
		private var isAppLoadCmpt:Boolean=false;
		private var LoadBarMainApp_x:Number=0;
		private var LoadBarMainApp_y:Number=0;
		//加载模块进度条坐标
		private var loadBarModule_x:Number=0;
		private var loadBarModule_y:Number=0;
		//弹出类型
		private var PopupMode:Number;
		//
		/**
		 * 画面最小尺寸 
		 */		
		protected var minStageWidth:Number=0,minStageHeight:Number=0;
		/**
		 * 画面最大尺寸 
		 */		
		protected var maxStageWidth:Number=0,maxStageHeight:Number=0;
		//更新背景时，以此交换来获得背景应该显示层数
		private var updateBackForDepath:Sprite;
		//应用程序的版本控制，主要防止当服务器swf更新后，客户浏览器加载的还是原来旧的版本。解决的办法就是在swf文件名后加"文件名.swf?v=xxx"
		private var appVersion:String;
		//是否显示debug信息
		private var isShowDebugMenu:Boolean;
		protected var menuDebug:ContextMenuItem ;
		protected var menuDebug_clr:ContextMenuItem;
		//用于保存当要修改加载块层的层级时，每次刷新还在指定层级用，因为，cutload定义的层会经常刷新生成，所以这个两个变量就是重新设回以前的层级
		private var Layer5_index:Number=-1000;
		//各层的索引值
		protected var spWatermark_index:Number;
		protected var tipManagement_index:Number;
		protected var tipNoStageManagement_index:Number;
		protected var Popup_index:Number;
		protected var spTop_index:Number;
		protected var containerAlign_index:Number;
		protected var spFrameParent_index:Number;
		protected var spBak_index:Number;
		//
		protected var config:Config;
		/**
		 * 初始化 
		 * 
		 */
		public function CutLoad()
		{
			this.addEventListener(Event.ADDED_TO_STAGE,addToStage);
			//
			funLoadModuleSwfCompt=function():void{}
			config=getConfig();
		}
		/**
		 * cutload获得配置文件的方法，重写这个方法可以重新设置cutload的一些配置信息，例如一些过渡效果。 
		 * @return 
		 * 
		 */		
		protected function getConfig():Config{
			return new Config();
		}
		//当加载到场景里时
		private function addToStage(e:Event):void{
			tipManagement_index=tipNoStageManagement_index=Popup_index=spTop_index=containerAlign_index=spFrameParent_index=spBak_index=-1;
			//
			isShowDebugMenu=false;
			//是否要自定义菜单
			if(!is_NOT_DIY_contextMenu()){
				var cm : ContextMenu = new ContextMenu();
				cm.hideBuiltInItems();
				cm.customItems=new Array();
				this.contextMenu=cm;
				menuDebug= new ContextMenuItem("show debug message",false);
				menuDebug.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT,menu_debug_onselect);
				//
				this.contextMenu.customItems.push(menuDebug);
				this.contextMenu.customItems.push(menuDebug_clr);
			}
			//
			var strTem123:String="⊙0⊙!!!     "+VERSION;
			trace(strTem123);
			//debug(strTem123,1);
			strTem123="smallerbird www.mkigm.com";
			//debug(strTem123,1);
			trace(strTem123);
			strTem123="---------------------------------";
			//debug(strTem123,1);
			trace(strTem123);
			if(is_NO_SCALE_TOP_LEFT()){
				stage.scaleMode=StageScaleMode.NO_SCALE;
				stage.align=StageAlign.TOP_LEFT;
			}
			stage.stageFocusRect = false;
			arrLibList=[getCutLoadLibPath(),"Load Lib ",getCutLoadUIPath(),"Load UI "];
			VersionMyApp="";
			//添加水印
			spWatermark=new Sprite();
			//
			updateBackForDepath=new Sprite();
			this.addChild(updateBackForDepath);
			//
			moduleData=new CArray();
			//如果不只是第一帧，说明是在flash ide里做为主文件
			if(this.totalFrames>1){
				debug("flash ide里做为主文件时，请确保第一帧不能加代码，特别是stop()",2);
				//第二帧停止
				this.addFrameScript(1,cutloadMainClass_for_frame2);
			}
			PopupMode=config.CutLoad_PopupMode();
			//
			//
			//
			debug("运行 initOther()",1);
			initOther();
			//
			//
			//
			this.stage.addEventListener(Event.RESIZE,funResize_for_setLoadBarMainAppCenterXY);
			funResize_for_setLoadBarMainAppCenterXY(null);
			//
			//
			//如果设置了主程序加载进度条，如果isLoadCompleteDo()返回设置为true时，这里需要设置，加载完，放完后，需要做的事件。这里设置主要为了在本地测试时，可以看到效果。
			if(loadBar!=null) if(loadBar.isLoadCompleteDo()) loadBar.setLoadCompleteDo(appLoadCompt_do);
			//
			if(loaderInfo.bytesLoaded==loaderInfo.bytesTotal){
				//如果加载了，这里就不用处理了。
				//debug("已经加载了，跳过加载处理。。",2);
				LoadAppCompleteChekDo();
			}else{
				loaderInfo.addEventListener(ProgressEvent.PROGRESS,appLoadProgress);
				loaderInfo.addEventListener(Event.COMPLETE,appLoadCompt);
			}
		}
		/**
		 * 是否自动改变影片的画面尺寸，默认不改变，你可以重写这个方法
		 * @return  true 自动改变影片的画面尺寸  false 不改变
		 * 
		 */		
		protected function is_NO_SCALE_TOP_LEFT():Boolean{
			return true;
		}
		/**
		 * 是否cutload不自定义右键菜单项
		 * @return false自定义   true要定义
		 * 
		 */		
		protected function is_NOT_DIY_contextMenu():Boolean{
			return false;
		}
		/**
		 * 获得cutload 外部代码库lib.swf 的路经，默认为:当前目录lib.swf 
		 * @return 
		 * 
		 */		
		protected function getCutLoadLibPath():String{
			return myURLPath+"lib";
		}
		/**
		 * 获得cutload 外部界面库ui.swf 的路经，默认为:当前目录lib.swf 
		 * @return 
		 * 
		 */		
		protected function getCutLoadUIPath():String{
			return myURLPath+"ui";
		}
		private function cutloadMainClass_for_frame2():void{
			if(!isAppLoadCmpt){
				stop();
				if(loadBar!=null){
					//trace("加自定义进度");
					var temLoadBar:Sprite=loadBar as Sprite;
					var spForTop:Sprite=new Sprite();
					this.addChild(spForTop);
					this.swapChildren(temLoadBar,spForTop);
					this.removeChild(spForTop);
				}
				debug("运行 frame2_do()");
				frame2_do();
			}
		}
		/**
		 * 第二帧时，会调用这个方法。可重写它，完成一些事件。 
		 * 
		 */		
		protected function frame2_do():void{
		}
		/**
		 * 开启全屏 
		 * 
		 */		
		public function FULL_SCREEN_ENABLE(isOk:Boolean=true):void{
			if(stage==null) return;
			try{
				if(isOk){
					stage.displayState = StageDisplayState.FULL_SCREEN; 	
				}else{
					stage.displayState = StageDisplayState.NORMAL; 	
				}
				
			}catch(e:SecurityError){
				
			}
			
		}
		/**
		 * 
		 * @param str 应用程序的版本号
		 * @return  
		 * 
		 */		
		public function set VersionMyApp(str:String):void{
			this.appVersion=str;
		}
		/**
		 * 获得/设置应用程序的版本控制，主要防止当服务器swf更新后，客户浏览器加载的还是原来旧的版本。解决的办法就是在swf文件名后加"文件名.swf?v=xxx" 
		 * @return 
		 * 
		 */		
		public function get VersionMyApp():String{
			return appVersion;
		}
		//程序真正开始处
		private function appStart():void{
			//去除专为主程序加载进度条居中显示的的，事件
			this.stage.removeEventListener(Event.RESIZE,funResize_for_setLoadBarMainAppCenterXY);
			//
			//进度条
			createLoadBar(false);
			var temLoadBar:Base=loadBar as Base;
			loadBar.showHide(false);
			//
			LoadBarMainApp_x=loadBarModule_x;
			LoadBarMainApp_y=loadBarModule_y;
			//
			temLoadBar.setXY(LoadBarMainApp_x,LoadBarMainApp_y,this);
			this.init();
		}
		//
		private var setLoadBarMainAppCenter_isOk_v:Boolean=false;
		private var setLoadBarMainAppCenter_isOk_h:Boolean=false;
		/**
		 * 设置主程序加载的进度条,居中显示,如果需要更复杂的方法来操作主程序的进度条坐标和尺寸位置，请重写LoadBarMainAppResize这个方法。每次主页尺寸修改都会调用它。
		 * @param hCenter
		 * @param vCenter
		 * 
		 */		
		public function setLoadBarMainAppCenter(hCenter:Boolean=true,vCenter:Boolean=true):void{
			setLoadBarMainAppCenter_isOk_v=vCenter;
			setLoadBarMainAppCenter_isOk_h=hCenter;
		}
		//更新 主程序加载的进度条,让它居中
		private function setLoadBarMainAppCenterXY():void{
			var  temLoadBar:Sprite=loadBar as Sprite;
			if(setLoadBarMainAppCenter_isOk_h) temLoadBar.x=(this.stage.stageWidth-temLoadBar.width)/2;
			if(setLoadBarMainAppCenter_isOk_v) temLoadBar.y=(this.stage.stageWidth-temLoadBar.height)/2;
		}
		/**
		 * 如果需要更复杂的方法来操作主程序的进度条坐标和尺寸位置，请重写它每次主页尺寸修改都会调用它。
		 * @param stageWidth
		 * @param stageHeight
		 *  @param loadBar
		 * 
		 */		
		protected function LoadBarMainAppResize(stageWidth:Number,stageHeight:Number,loadBar:ILoadBar):void{
			
		}
		/**
		 * 当主页面的尺寸改变时，会调用这个方法。如果需要设置加载模版进度条根据尺寸修改的话，可以重写这个方法。
		 * @param stageWidth
		 * @param stageHeight
		 * @param loadBar
		 * 
		 */		
		protected function LoadBarModuleAppResize(stageWidth:Number,stageHeight:Number,loadBar:ILoadBar):void{
		}
		//这里为了当窗口尺寸变时，主程序加载的进度条，居中，需要在cutload之前注册别外一个事件。
		private function funResize_for_setLoadBarMainAppCenterXY(e:Event):void{
			if(loadBar!=null&&stage!=null){
				if(setLoadBarMainAppCenter_isOk_v||setLoadBarMainAppCenter_isOk_h){
					//如果设置居中，就居中
					setLoadBarMainAppCenterXY();
				}
				//通过自定义的程序修改
				LoadBarMainAppResize(stage.stageWidth,stage.stageHeight,loadBar);
			}
			
		}
		/**
		 * 设置主程序加载的进度条 
		 * @param newLoadbar 要替换的进度条必须实现这个接口：CutLoad.components.ILoadBar
		 * @param xx 显示的位置x
		 * @param yy 显示的位置y
		 * 
		 */
		public function setLoadBarMainApp(newLoadbar:ILoadBar,xx:Number,yy:Number):void{
			//如果主程序已经加载成，此方法无效
			if(isAppLoadCmpt){
				CutLoad.CutLoad.debug("警告：此方法调用无效 setLoadBarMainApp(.....)",2);
				return;
			}
			if(!(newLoadbar is Base)) throw new Error("设置的进度条必须是Base子类，同时实现ILoadBar接口");
			var temLoadBar:Sprite
			if(loadBar!=null){
				temLoadBar=loadBar as Sprite;
				this.removeChild(temLoadBar);
				loadBar=null;
			}
			LoadBarMainApp_x=xx;
			LoadBarMainApp_y=yy;
			loadBar=newLoadbar;
			temLoadBar=loadBar as Sprite;
			temLoadBar.x=xx;
			temLoadBar.y=yy;
			this.addChild(temLoadBar);
			cutloadMainClass_for_frame2()
		}
		/**
		 * 弹出的效果
		 * @param type 0:没有效果直接出现  1:像弹簧那样弹出效果
		 * 
		 */		
		public function setPopupMode(type:Number=0):void{
			if(type==0){
				this.PopupMode=0;
			}else{
				this.PopupMode=1;
			}
		}
		/**
		 * 垃圾回收 
		 * 
		 */		
		public static function OptimizeMemory():void{
			debug("垃圾回收:CutLoad.OptimizeMemory()",1);
			try{
				new LocalConnection().connect("www_mkigm_com_forOptimize_asdf");
				new LocalConnection().connect("www_mkigm_com_forOptimize_asdf");
			}catch(error : Error){
			}
		}
		/**
		 * 输出测试信息 
		 * @param str 信息内容
		 * @param type 信息类型 0：正常输出信息 1:系统,2:警告
		 * 
		 */
		public static function debug(str:String,type:Number=0):void{
			if(DEBUG_MESSAGE.length>=DEBUG_MESSAGE_LENGTH){
				//只保留几行，如果超过就去掉
				DEBUG_MESSAGE.shift();
			}
			DEBUG_JS++;
			switch(type){
				case 1:
					trace("系统:"+str);
					str=DEBUG_JS+" : <font color=\"#0000FF\"><b>系统      </b>"+str+"</font>";
					break;
				case 2:
					trace("警告:"+str);
					str=DEBUG_JS+" : <font color=\"#FF0000\"><b>警告      </b>"+str+"</font>";
					break;
				default:
					trace("调试:"+str);
					str=DEBUG_JS+" : <font color=\"#666666\"><b>调试      </b>"+str+"</font>";
					break;
			}
			DEBUG_MESSAGE.push("<br>"+str);
		}
		/**
		 * 设置调试密码 
		 * @param str
		 * @return 
		 * 
		 */		
		public static function setDebugPWD(str:String):void{
			DEBUG_PASSWORD=str;
		}
		/**
		 * 设置调试保留保留的行数 
		 * 
		 */		
		public static function setDebugMsgLength(num:Number):void{
			DEBUG_MESSAGE_LENGTH=num;
		}
		/**
		 * 获得：SWF 文件提供的参数 ,是对root.loaderInfo.parameters的简写.
		 * <p>关于：SWF 文件提供的参数：用的最多的就是来自网页插入flash里转入的参数：<param name=”flashvars” value=”xxxxx″ /></p>
		 * @return 
		 * 
		 */		
		public function getFlashvars():Object{
			return root.loaderInfo.parameters;
		}
		/**
		 * 是否开启debug模式 
		 * @param isDebug true是启用,false不启用
		 * 
		 */		
		public function set debugEnabled(isDebug:Boolean):void{
			if(isDebug){
				if(menuDebug!=null) return;
			}else{
				//清除调试用到的两个选项
				if(isShowDebugMenu){
					if(menuDebug!=null){
						for(var i:Number=0;i<this.contextMenu.customItems.length;i++){
							if(this.contextMenu.customItems[i]==menuDebug){
								this.contextMenu.customItems.splice(i,1);
								this.contextMenu.customItems.splice(i,1);
								menuDebug=null;
								menuDebug_clr=null;
								break;
							}
						}
					}
				}
			}
			isShowDebugMenu=isDebug;
		}
		/**
		 * 获得当前右键菜单数组，注：这个数组里面有使用：hideBuiltInItems，同时如果设置cutload.debugEnabled(true) 还会显示调试用到的两个选项,所有修改的时候请小心
		 * @return 
		 * 
		 */		
		public function getMenuCustomItems():Array{
			return this.contextMenu.customItems;
		}
		/**
		 * 显示调试窗口信息 
		 * 
		 */		
		public function showDebugWin():void{
			if(isNotUseUi){
				return;
			}
			if(cwindpwd!=null) return;
			cwindpwd=new CWindow();
			cwindpwd.init("请输入密码",true,true,false,270,60);
			cwindpwd.setFunCloseBtn(function():void{
				getLayer2_popup().removeTop();
				cwindpwd=null;
			});
			var ctem:ContainerH=new ContainerH();
			ctem.init({w:300,isAuto:false,xspace:5,yspace:5});
			var txtpwd:CTextInput=CTextInput.getSimple();
			txtpwd.setIsPwd(true);
			txtpwd.setWH(200,20);
			var btnpwdLogin:CButton=CButton.getSimpleBtn("登录");
			btnpwdLogin.setOtherInfo({txtPwd:txtpwd});
			btnpwdLogin.addEventListener(MouseEvent.CLICK,function(e:MouseEvent):void{
				var obj:CTextInput=e.target.getOtherInfo().txtPwd;
				if(obj.text==DEBUG_PASSWORD){
					getLayer2_popup().removeTop();
					showDebugWin_msg();
				}else{
					alert(":(","debug pwd wrong!!!");
				}
			});
			ctem.appendSome([txtpwd,btnpwdLogin]);
			cwindpwd.getContainer().append(ctem);
			this.getLayer2_popup().popup(cwindpwd);
		}
		/**
		 * 获得debug信息 
		 * @return 
		 * 
		 */		
		public static function getDebugMsg():String{
			var strReturn:String="";
			for(var i:Number=0;i<DEBUG_MESSAGE.length;i++){
				strReturn+=DEBUG_MESSAGE[i]
			}
			return strReturn;
		}
		/**
		 * 显示真正的信息 
		 * 
		 */		
		public function showDebugWin_msg():void{
			if(winDebug!=null) return;
			winDebug=new CWindowTextArea();
			winDebug.init("调试信息片段 :)___",true,false,false,this.getShowWidth()-100,this.getShowHeight()-100);
			winDebug.getPartWindow().getContainer().setBakColor(0xffffff,1);
			winDebug.htmlText=getDebugMsg();
			winDebug.getTextArea().getScroll().moveBarEnd();
			winDebug.setFunClose(closeWinDebug);
			this.getLayer2_popup().popup(winDebug);
		}
		//弹出调试信息面板
		private function menu_debug_onselect(e:ContextMenuEvent):void{
			showDebugWin();
		}
		private function closeWinDebug(me:CWindowTextArea):void{
			this.getLayer2_popup().removeTop();
			winDebug=null;
			cwindpwd=null;
		}
		/**
		 * 添加系统初始化是加载额外的swf库文件. 注:系统默认会加载lib.swf库文件(这里不添加)，其中包括了cutload所有的内容，如果有一些素材库，
		 * 可以放在别外的swf文件里，然后加载进去。要在使用cutload.init(...)方法前使用。
		 * @param swfname 加载的库文件名 ,注：文件件名不包括".swf"
		 * @param describe 该库文件的描述信息
		 * 
		 */		
		public function addLoadLibList(swfname:String,describe:String):void{
			arrLibList.push(swfname);
			arrLibList.push(describe);
		}	
		//主程序加载过程
		private function appLoadProgress(the:ProgressEvent):void {
			//trace("appLoadProgress:::"+(the.bytesLoaded/the.bytesTotal));
			if(loadBar!=null){
				loadBar.setValue(the.bytesLoaded/the.bytesTotal,"");
			}
		}
		/**
		 * 获得当前文件完全路径
		 * @return 
		 * 
		 */		
		public function get myURL():String{
			if(this.loaderInfo==null) return "";
			if(this.loaderInfo.url==null) return "";
			return this.loaderInfo.url;
		}
		/**
		 * 获得当前文件所在目录
		 * @return 
		 * 
		 */		
		public function get myURLPath():String{
			//return "http://balala.auldey.com/balala_addSoud/";
			var urlTem:String=myURL;
			if(urlTem=="") return "";
			return Fun.getFilePathStr(urlTem);
		}
		/**
		 * 判断进度条是否要运行，加载完后需要处理的事情 
		 * 
		 */		
		protected function LoadAppCompleteChekDo():void{
			if(loadBar!=null){
				if(loadBar.isLoadCompleteDo()){
					loadBar.loadComplete();
				}else{
					appLoadCompt_do();
				}
			}else{
				appLoadCompt_do();
			}
		}
		//主程序加载完成
		private function appLoadCompt(e:Event):void{
			//
			//trace("主程序加载完成");
			LoadAppCompleteChekDo();
			//
		}
		private function appLoadCompt_do():void{
			//trace("appLoadCompt_do");
			isAppLoadCmpt=true;
			root.loaderInfo.removeEventListener(ProgressEvent.PROGRESS,appLoadProgress);
			root.loaderInfo.removeEventListener(Event.COMPLETE,appLoadCompt);
			//直接加进去的，与后边的进度条所在的显示对象是不一样，所以用完之后要删除
			if(loadBar!=null){
				var loadBarBase:Sprite=loadBar as Sprite;
				if(loadBarBase!=null) if(loadBarBase.parent==this) this.removeChild(loadBarBase);
				loadBar=null;
			}
			if(this.totalFrames>1){
				play();
				if(whenAppLoadCompt!=null) whenAppLoadCompt();
			}
			appStart();
		}
		//当应用程序加载完成时要执行的额外的程序
		private var whenAppLoadCompt:Function=null
		/**
		 * 当应用程序加载完成时要执行的额外的程序,注：此方法只要当应用程序是多帧时才起作用。如果你的应用主程序有多帧时。加载程序会在每二帧处添加一个stop,然后开始预加载。加载完以后，会自动调用play开始放。如果此时你不需要开始放，你可以在使用这个方法停止下来。
		 * @param fun 额外的执行 格式：function()
		 * 
		 */		
		public function setFunWhenAppLoadCompt(fun:Function):void{
			if(this.totalFrames==1){
				CutLoad.CutLoad.debug("CutLoad.setFunWhenAppLoadCompt(...) 此方法只要当应用程序是多帧时才起作用!",2);
				return;
			}
			whenAppLoadCompt=fun;
		}
		//当场景初始化完后，cutload进行的所有初始化。 
		private function init():void{
			//
			init_noLoadLib();
			//如果设置了不加载库时
			if(isNotUseUi){
				this.setLayerChildIndex_allTop();
				this.main();
				return;
			}
			//				
			load(arrLibList[arrLibListIndex++],arrLibList[arrLibListIndex++], 1);
		}
		/**
		 * 不加载库文件的初始化方法
		 * <p>注：如果用flash软件直接引用了lib.fla里的库文件的话，就不需要加载lib.swf,这个文件了。因为生成的flash已存在lib.swf里所有的东西。</p>
		 * <p>有些场合我们不需要把一个应用分割成很多份里，就可以用这个方法了。</p> 
		 * 
		 */		
		private function init_noLoadLib():void{
			stage.addEventListener(Event.RESIZE,funResize);
			iniDiv()
		}
		/**
		 * 定制cutload初始化：覆盖这个方法，可以定制初始时的一些方法。 
		 * @return 
		 * 
		 */		
		public function initOther():void{
			
		}
		/**
		 * 应用程序的入口方法：完成所有初始化后，调用的方法。所有这里是我们编写应用开始的入口点：我们可以重写这个方法。做为应用程序的入口。
		 * 
		 */		
		public function main():void{
		}
		/**
		 * 设置初始化时，不自动加载lib.swf,ui.swf,有的时候你或许不需要使用cutload的ui，只是想使用一些代码。你可以在编写自己的主类时的构造方法中，调用这个方法。 不过此时，有很多方法都不能使用。主要是那些涉及到ui皮肤的那些，如果你调用它们，会提示找不到元件的类似错误。
		 * 
		 */		
		public function doNotLoadDefaultLib():void{
			isNotUseUi=true;
			//默认会检测是否加载两个库文件（lib.swf,ui.swf），所以这里要设置true
			isLoadMain=true;
		}
		private function updateBack():void{
			if(spBak!=null){
				this.swapChildren(updateBackForDepath,spBak);
				this.removeChild(spBak);
			}
			spBak=new CRender();
			spBak.mouseChildren=false;
			spBak.mouseEnabled=false;
			if(bakSaveConfig_obj==null){
				bakSaveConfig_type=0;
				bakSaveConfig_obj={color:0xff0000,alpha:0,isBitmap:false};
			}
			spBak.mouseEnabled=false;
			spBak.mouseChildren=false;
			spBak.init(bakSaveConfig_way,bakSaveConfig_type,bakSaveConfig_obj,this.getShowWidth(),this.getShowHeight());
			this.addChild(spBak);
			this.swapChildren(updateBackForDepath,spBak);
		}
		//清除当前模版
		private function removeCurrentModule():void{
			if(currentModule!=null){
				currentModule.killMe();
				if(currentModule.parent!=null) spFrameParent.removeChild(currentModule);
				currentModule=null;
			}
		}
		//初使化局面
		protected function iniDiv():void{
			this.funResizeDo=null;
			//
			arrResize=new Array();
			//背景
			updateBack()
			//显示加载的模块
			removeCurrentModule();
			if(spFrameParent!=null) this.removeChild(spFrameParent);
			spFrameParent=new Sprite();
			this.addChild(spFrameParent);
			//
			//对齐
			if(containerAlign!=null) this.removeChild(containerAlign);
			containerAlign=new Container();
			containerAlign.init({w:this.getShowWidth(),h:this.getShowHeight(),lt_transition:config.CutLoad_addAlign_transition()});
			containerAlign.clrBak();
			this.addChild(containerAlign);
			//最顶
			if(spTop!=null) this.removeChild(spTop);
			spTop=new Sprite();
			this.addChild(spTop);
			//弹出
			if(Popup!=null) this.removeChild(Popup);
			if(PopupMode==0){
				Popup=new CPopup();
			}else{
				Popup=new CPopupSpring();
			}
			Popup.init(this.getShowWidth(),this.getShowHeight());
			this.addChild(Popup);
			//重新把进度条加上
			if(loadBar!=null) addLoadBar();
			//清除提示,并放在最上边
			if(tipNoStageManagement!=null){
				tipNoStageManagement.clearAll();
				Fun.setTopDepath(tipNoStageManagement);
			}
			if(tipManagement!=null){
				tipManagement.clearAll();
				Fun.setTopDepath(tipManagement);
			}
			//水印
			if(spWatermark.parent!=null) this.removeChild(spWatermark);
			this.addChild(spWatermark);
		}
		/**
		 * 重置所有层 
		 * @return 
		 * 
		 */		
		public function resetLayer():void{
			this.iniDiv();
		}
		/**
		 * 获得各层的引用,关于层的结构如下。
		 * <ol><b>注意事项</b>
		 * <li>关于索引值范围：0为最上层,5为最下层</li>
		 * <li>特别要注意：虽然这些层都是继承自Sprite,但它们有着不同的功能,如果你向他们内部用addChild(..)方法添加对象，最后手动清除它们。</li>
		 * <li>特别要注意：虽然这些层都是继承自Sprite,但它们有着不同的功能，需类型转换后才可以具体用它们。如果这样你觉得麻烦，你可以调用CutLoad这个类的以getLayer为前缀的具体方法。</li>
		 * </ol>
		 * <ol><b>关于各层说明</b>
		 * <li>0:全局提示管理容器[类型：CTipManagement]</li>
		 * <li>1:相对提示管理容器[类型：CTipManagement]</li> 
		 * <li>2:弹出[类型：CPopup]</li>
		 * <li>3:最顶[类型：Sprite]</li>
		 * <li>4:放置全局对齐的容器[类型：Container]</li>
		 * <li>5:放置加载模块[类型：Sprite]</li>
		 * <li>6:整个背景[类型：CRender]</li>
		 * </ol>
		 * @param index
		 * @return 
		 * 
		 */		
		public function getLayer(index:Number):Sprite{
			if(index<0||index>6) throw new Error("层的索引值只能设为:0~6");
			switch(index){
				case -1:
					return spWatermark;
				case 0:
					return tipManagement;
					break;
				case 1:
					return tipNoStageManagement;
					break;
				case 2:
					return Popup;
					break;
				case 3:
					return spTop;
					break;
				case 4:
					return containerAlign;
					break;
				case 5:
					return spFrameParent;
					break;
				default:
					return spBak;
					break;
			}
		}
		/**
		 * 将cutload用到层，集体改在最上边。 
		 * @return 
		 * 
		 */		
		public function setLayerChildIndex_allTop():void{
			spBak_index=Fun.setTopDepath(this.getLayer6_bak());
			spFrameParent_index=Fun.setTopDepath(this.getLayer5_module());
			containerAlign_index=Fun.setTopDepath(this.getLayer4_align());
			spTop_index=Fun.setTopDepath(this.getLayer3_top());
			Popup_index=Fun.setTopDepath(this.getLayer2_popup());
			tipNoStageManagement_index=Fun.setTopDepath(this.getLayer1_tipNoStageManagement());
			tipManagement_index=Fun.setTopDepath(this.getLayer0_tipManagement());
			spWatermark_index=Fun.setTopDepath(spWatermark);
		}
		/**
		 * 设置各层的索引位置
		 * @param tipManagement_index
		 * @param tipNoStageManagement_index
		 * @param Popup_index
		 * @param spTop_index
		 * @param containerAlign_index
		 * @param spFrameParent_index
		 * @param spBak_index
		 * @return 
		 * 
		 */		
		public function setLayerChildIndex(tipManagement_index:Number,
										   tipNoStageManagement_index:Number,
										   Popup_index:Number,
										   spTop_index:Number,
										   containerAlign_index:Number,
										   spFrameParent_index:Number,
										   spBak_index:Number
		):void{
			this.tipManagement_index=tipManagement_index;
			this.tipNoStageManagement_index=tipNoStageManagement_index;
			this.Popup_index=Popup_index;
			this.spTop_index=spTop_index;
			this.containerAlign_index=containerAlign_index;
			this.spFrameParent_index=spFrameParent_index;
			this.spBak_index=spBak_index;
			updateLayerChildIndex();
			//
		}
		//更新索引
		private function updateLayerChildIndex():void{
			if(tipManagement_index==-1){
				tipManagement_index=this.getChildIndex(getLayer0_tipManagement());
			}else{
				this.setChildIndex(this.getLayer0_tipManagement(),tipManagement_index);
			}
			if(tipNoStageManagement_index==-1){
				tipNoStageManagement_index=this.getChildIndex(getLayer1_tipNoStageManagement());
			}else{
				this.setChildIndex(this.getLayer1_tipNoStageManagement(),tipNoStageManagement_index);
			}
			if(Popup_index==-1){
				Popup_index=this.getChildIndex(getLayer2_popup());
			}else{
				this.setChildIndex(this.getLayer2_popup(),Popup_index);
			}
			if(spTop_index==-1){
				spTop_index=this.getChildIndex(getLayer3_top());
			}else{
				this.setChildIndex(this.getLayer3_top(),spTop_index);
			}
			if(containerAlign_index==-1){
				containerAlign_index=this.getChildIndex(getLayer4_align());
			}else{
				this.setChildIndex(this.getLayer4_align(),containerAlign_index);
			}
			if(spFrameParent_index==-1){
				spFrameParent_index=this.getChildIndex(getLayer5_module());
			}else{
				this.setChildIndex(this.getLayer5_module(),spFrameParent_index);
			}
			if(spBak_index==-1){
				spBak_index=this.getChildIndex(getLayer6_bak());
			}else{
				this.setChildIndex(this.getLayer6_bak(),spBak_index);
			}
		}
		/**
		 * 添加水印 
		 * @param sp
		 * 
		 */		
		public function WatermarkAppend(sp:Sprite):void{
			this.spWatermark.addChild(sp);
		}
		/**
		 * 添加文本 水印 
		 * @param str 文本内容
		 * @param align 对齐方式：0左,1中,2右
		 * @param color 字色
		 * @param size 字尺寸
		 * @return 
		 * 
		 */		
		public function WatermarkTxtAppend(str:String,align:uint=0,color:Number=0xff0000,size:Number=13):CTextField{
			var fmt:TextFormat=CTextField.getTextFormat(align,color,size);
			var txtTem:CTextField=CTextField.getSimpleTxt(str,fmt);
			WatermarkAppend(txtTem);
			return txtTem
		}
		/**
		 * 清除所有水印 
		 * 
		 */		
		public function WatermarkAppendClrAll():void{
			if(this.spWatermark==null) return;
			if(this.spWatermark.parent!=null){
				this.removeChild(this.spWatermark);
				this.spWatermark=null;
			}
			spWatermark=new Sprite();
			this.addChild(this.spWatermark);
		}
		/**
		 * 获得层0,详见：CutLoad.getLayer(..)方法注释各层说明
		 * @see CutLoad.getLayer()
		 * @return 
		 * 
		 */		
		public function getLayer0_tipManagement():CTipManagement{
			return tipManagement;
		}
		/**
		 * 获得层1,详见：CutLoad.getLayer(..)方法注释各层说明
		 * @return 
		 * 
		 */	
		public function getLayer1_tipNoStageManagement():CTipManagement{
			//if(tipNoStageManagement==null) throw new Error("相对提示管理器为空!");
			return tipNoStageManagement;
		}
		/**
		 * 获得层2,详见：CutLoad.getLayer(..)方法注释各层说明
		 * @return 
		 * 
		 */	
		public function getLayer2_popup():CPopup{
			return Popup;
		}
		/**
		 * 获得层3,详见：CutLoad.getLayer(..)方法注释各层说明
		 * @return 
		 * 
		 */	
		public function getLayer3_top():Sprite{
			return spTop;
		}
		/**
		 * 获得层4,详见：CutLoad.getLayer(..)方法注释各层说明
		 * @return 
		 * 
		 */	
		public function getLayer4_align():Container{
			return containerAlign;
		}
		/**
		 * 获得层5,详见：CutLoad.getLayer(..)方法注释各层说明
		 * @return 
		 * 
		 */	
		public function getLayer5_module():Sprite{
			return spFrameParent;
		}
		/**
		 * 获得层6,详见：CutLoad.getLayer(..)方法注释各层说明
		 * @return 
		 * 
		 */	
		public function getLayer6_bak():CRender{
			return spBak;
		}
		/**
		 * 刷新提示框 位置,注：cutLoad.refreshLayout()有包括了这个方法。还有当场景改变时也会自动调用它.
		 * @param type 0刷新相对场景坐标的提示框，1:刷新不是相对场景坐标的提示框,2:两个都刷新  注：默认为0
		 * 
		 */		
		public function refreshTip(type:Number=0):void{
			if(type==0||type==2){
				if(tipManagement!=null) this.tipManagement.update();
			}
			if(type==1||type==2){
				if(tipNoStageManagement!=null) tipNoStageManagement.update();
			}
		}
		/**
		 * 添加一个提示框 
		 * @param base 要添加提示框的对象
		 * @param content 提示的内容
		 * @param tipWidth 提示框宽度
		 * @param isUpdateRect 是否更新所有的提示框必要的信息。默认true,注：打开会很耗时。当同时要加后多时，可以在前面调用此方法设置false,最后调用这个方法时设置为true.
		 * 
		 */		
		public function tip(base:Sprite,content:String,tipWidth:Number=0,isUpdateRect:Boolean=true):void{
			iniTip()
			tipManagement.add(base,content,tipWidth,isUpdateRect);
		}
		//初始化 提示框管理对象
		private function iniTip():void{
			if(tipManagement==null){
				//提示管理容器
				tipManagement=new CTipManagement();
				this.addChild(tipManagement);
				tipManagement.init();
			}
		}
		/**
		 * 初始化 不相对场景的 提示框管理对象
		 * 
		 */		
		public function iniTipNoStageManagement():void{
			if(tipNoStageManagement==null){
				//提示管理容器
				tipNoStageManagement=new CTipManagement();
				this.addChild(tipNoStageManagement);
				tipNoStageManagement.init();
				tipNoStageManagement.stop();
			}
		}
		/**
		 * 获得进度条的引用 
		 * @return 
		 * 
		 */		
		public function getLoadBar():ILoadBar{
			return loadBar
		}
		//将模块进度条加到页里里
		private function addLoadBar():void{
			//如果设置了坐标就不居中
			//trace("addLoadBar:LoadBarMainApp_x:"+LoadBarMainApp_x+" LoadBarMainApp_y:"+LoadBarMainApp_y);
			if(LoadBarMainApp_x==NULLNO&&LoadBarMainApp_y==NULLNO){
				this.addAlign((loadBar as Base));
			}else{
				this.getLayer4_align().appendXY(loadBar as Base,LoadBarMainApp_x,LoadBarMainApp_y);
			}
		}
		//显示进度条
		private function createLoadBar(isAdd:Boolean=true):void{
			if(loadBar!=null){
				loadBar.showHide(true);
				//trace("loadBar.showHide(true);");
				return;
			}
			if(clone_loadBar==null){
				//clone_loadBar=new Loadbar(200,20,0x000000,12,0xffffff,1,1,0xcccccc,1,0x000000,1)
				clone_loadBar=new LoadbarForCutLoad();
			}
			loadBar=clone_loadBar.clone();
			//如果主程加载程序条，这里不用
			if(isAdd){
				addLoadBar()
			}
		}
		/**
		 * 删除加载的进度条 
		 * 
		 */			
		public function removeLoadBar():void{
			//trace("removeLoadBar ");
			loadBar.setValue(0,"");
			loadBar.showHide(false);
		}
		/**
		 * 替换加载模块的进度条
		 * @param newLoadbar 要替换的进度条必须实现这个接口：CutLoad.components.ILoadBar
		 * @param xxx 进度条显示坐标x，默认0，如果需要居中显示,可以传入：CutLoad.CutLoad.NULLNO
		 * @param yyy 进度条显示坐标y，默认0，如果需要居中显示,可以传入：CutLoad.CutLoad.NULLNO
		 * 
		 */		
		public function setLoadBar(newLoadbar:ILoadBar,xxx:Number=0,yyy:Number=0):void{
			if(!(newLoadbar is Base)) throw new Error("设置的进度条必须是Base子类，同时实现ILoadBar接口");
			loadBarModule_x=xxx;
			loadBarModule_y=yyy;
			clone_loadBar=newLoadbar;
		}
		
		//
		private var bakSaveConfig_type:uint=0;
		private var bakSaveConfig_way:uint=0;
		private var bakSaveConfig_obj:Object=null;
		/**
		 * 修改背景，详见 CutLoad.components.CRender.init(...) 说明
		 * @param type
		 * @param config
		 * 
		 */		
		public function setBak(way:uint,type:uint,config:Object):void{
			bakSaveConfig_obj=config;
			bakSaveConfig_type=type
			bakSaveConfig_way=way;
			updateBack();
		}
		/**
		 * 修改纯色背景 
		 * @param bakColor 背景色
		 * @param bakAlpha 背景透明度
		 * @param isBitmap 是否将纯色背景生成图片
		 * 
		 */		
		public function setColorBak(bakColor:Number,bakAlpha:Number=1,isBitmap:Boolean=false):void{
			setBak(0,0,{color:bakColor,alpha:bakAlpha,isBitmap:isBitmap});
		}
		/**
		 * 帧频 
		 * @param fps
		 * 
		 */		
		public function set fps(f:Number):void{
			if(stage==null) return;
			stage.frameRate=f;
		}
		/**
		 * 帧频 
		 * @return 
		 * 
		 */		
		public function get fps():Number{
			if(stage==null) return 0;
			return stage.frameRate
		}
		//加载-----------------------------------------------start------------------------------------------
		private var loadLibCompelet:Function=null;
		/**
		 * 加一个库文件 ,如果在程序途中需要加载库文件，可以用这个方法
		 * @param p_url SWF地址,注：不用带".swf"
		 * @param loadbarTalkYou 加载的进度条提示信息
		 * @param loadLibCompelet 加载完成执行的方法,注：这个方法只会执行一次，运行完以后会被立即设为null.
		 * 
		 */		
		public function loadLibSwf(p_url : String,loadbarTalkYou:String="",loadLibCompelet:Function=null):void{
			if(loadLibCompelet==null) loadLibCompelet=function():void{};
			this.loadLibCompelet=loadLibCompelet;
			load(p_url,loadbarTalkYou,1);
		}
		//以下变量用于，当没有找到加载文件时，尝试重新加载时使用----------------------------
		private var forLoader_load:Loader=null;
		private var forLoader_load_url:URLRequest=null;
		private var forLoader_load_context:LoaderContext=null;
		private var forLoader_load_i:Number=0;
		private var forLoader_load_icount:Number=5;
		//重新尝试加载
		private function reLoad():void{
			forLoader_load_i++;
			if(forLoader_load_i<=forLoader_load_icount){
				if(forLoader_load!=null&&forLoader_load_url!=null&&forLoader_load_context!=null){
					debug("尝试加载:"+forLoader_load_url+"   ==>  第"+forLoader_load_i+"次",1)
					forLoader_load.load(forLoader_load_url,forLoader_load_context);	
				}
			}
			if(forLoader_load_i==forLoader_load_icount){
				forLoader_load_i=0;
				forLoader_load=null;
				forLoader_load_url=null;
				forLoader_load_context=null;
			}
		}
		/**
		 * 设置重新加载的次数，注：在实际的网络环境中，常会因为网络问题，有时候加载文件会没有找到。所以cutload会尝试再次加载。默认设置是尝试加载5次，你也可以设置其它的值
		 * @param num
		 * 
		 */		
		public function setReLoadTimes(num:Number):void{
			forLoader_load_icount=num;
		}
		private var loadbarTalkYou:String="";
		/**
		 * 加载SWF
		 * 
		 * @param p_url		SWF地址,注：不用带".swf"
		 * @param p_url	加载的进度条提示信息
		 * @param p_target	加载到哪个ApplicationDomain  1同域,0子域,2新域
		 */
		protected function load(p_url : String,loadbarTalkYou:String="", p_target:Number=0) : void
		{
			p_url=p_url+".swf";
			if(VersionMyApp!==""){
				p_url+="?"+VersionMyApp;
			}
			//trace("load....:::"+p_url)
			debug("[load]  "+loadbarTalkYou+"--->"+p_url,1);
			nowLoadSwfName=p_url;
			if(loadbarTalkYou=="") loadbarTalkYou="Load:"+p_url+" ";
			this.loadbarTalkYou=loadbarTalkYou;
			//进度条提示信息
			createLoadBar()
			loadBar.setValue(0,loadbarTalkYou);
			LoadBarModuleAppResize(this.getShowWidth(),this.getShowHeight(),loadBar);
			this.update();
			//
			var loader:Loader = new Loader();
			var context:LoaderContext = new LoaderContext();
			switch (p_target)
			{
				case 0 :
					context.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
					break;
				case 1 :
					context.applicationDomain = ApplicationDomain.currentDomain;
					break;
				case 2 :
					context.applicationDomain = new ApplicationDomain();
					break;
				default:
					throw new Error("只能是这几个值:1同域,0子域,2新域");
					break;
			}
			this.initLoadEvent(loader.contentLoaderInfo);
			//
			forLoader_load=loader;
			forLoader_load_context=context;
			forLoader_load_url=new URLRequest(p_url);
			loader.load(forLoader_load_url, context);
		}
		//---------------------加载前先播放离开动画----------------
		private var LoadModuleSwf_doThisLater_endDo_swfName:String;
		//播放当前加载的模版的离开动画，放完调用的方法。加载下一个模版文件。
		private function LoadModuleSwf_doThisLater_endDo_fun():void{
			LoadModuleSwf(LoadModuleSwf_doThisLater_endDo_swfName);
		}
		/**
		 * 播放当前加载的模版的离开动画，放完调用的方法。加载下一个模版文件。
		 * @param swfName
		 * 
		 */		
		public function LoadModuleSwf_doThisLater(swfName:String):void{
			//debug("LoadModuleSwf_doThisLater-->"+swfName);
			if(this.currentModule==null){
				LoadModuleSwf(swfName);
				return;	
			}
			swfName=swfName.toLocaleLowerCase();
			if(swfName.indexOf(".swf")!=-1) throw new Error("不要加.swf");
			if(swfName==this.currentModuleData.url) return;
			LoadModuleSwf_doThisLater_endDo_swfName=swfName;
			this.currentModule.leaveMovieStart(LoadModuleSwf_doThisLater_endDo_fun);
		}
		//
		private var funLoadModuleSwfCompt:Function;
		/**
		 * 加载某一个画面到第5层，关于层的结构，请查看：CutLoad.getLayer()的说明
		 * @param swfName  swf文件名，注：不要加".swf"
		 * @param describe 描述信息 默认为空时，会显示:"load:文件名.swf"
		 * @param p_target 默认为：0,其它参数：1同域,0子域,2新域
		 * @param funLoadModuleSwfCompt 加载完以后，执行的方法。
		 * @param isOptimizeMemory 是否内存整理,默认为需要
		 * @return 
		 * 
		 */	
		public function LoadModuleSwf(swfName:String,describe:String="",p_target:Number=0,funLoadModuleSwfCompt:Function=null,isOptimizeMemory:Boolean=true):void{
			debug("LoadModuleSwf -> :"+swfName);
			swfName=swfName.toLocaleLowerCase()
			if(swfName.indexOf(".swf")!=-1) throw new Error("不要加.swf");
			//
			if(currentModuleData!=null){
				if(currentModuleData.url==swfName){
					//如果加载的就是当前显示，无视
					debug("LoadModuleSwf 当前就是",2);
					return;
				}
			}
			if(funLoadModuleSwfCompt!=null)  this.funLoadModuleSwfCompt=funLoadModuleSwfCompt;
			//如果是加载入口文件，就不用iniDiv()
			//if(isLoadMain) iniDiv();
			//模块数据有无保存
			var indexTem:Number=moduleData.seachOne(swfName,ModuleData.URL)
			if(indexTem==-1){
				currentModuleData=new ModuleData(swfName);
				//trace("LoadModuleSwf:"+currentModuleData);
				moduleData.add(currentModuleData);
			}else{
				currentModuleData=moduleData.getOne(indexTem) as ModuleData;
			}
			removeCurrentModule();
			//加载模块
			load(swfName,describe, p_target);
			if(!isLoadMain) isLoadMain=true;
			if(isOptimizeMemory) OptimizeMemory();
		}
		/**
		 * 清除当前加载的模块文件 
		 * @return 
		 * 
		 */		
		public function delCurrentModuleSwf():void{
			if(isLoadMain) iniDiv();
		}
		/**
		 * 获得当前加载的模块文件 
		 * @return 
		 * 
		 */		
		public function getCurrentModule():ModuleBase{
			if(this.currentModule==null) throw new Error("当前加载的模块文件为空");
			return this.currentModule;
		}
		/**
		 * 获得一个模块文件的数据 
		 * @param url 文件名,注不要加:".swf" 
		 * @return 
		 * 
		 */		
		public function ModuleDataGet(url:String):ModuleData{
			if(url.indexOf(".swf")!=-1) throw new Error("不要加.swf");
			var indexTem:Number=moduleData.seachOne(url,ModuleData.URL);
			if(indexTem==-1){
				throw new Error("没有找到这个模块文件的保存数据区域:"+url);	
			}
			return (moduleData.getOne(indexTem) as ModuleData);
		}
		/**
		 * 建立 一个模块文件数据
		 * @param md 模块数据
		 * 
		 */		
		public function ModuleDataCreate(md:ModuleData):void{
			if(ModuleDataHave(md)){
				throw new Error("建立这个模块文件的保存数据区域时出错，因为它已存在,请用ModuleDataCreate()先删除");
			}
			moduleData.add(md);
		}
		/**
		 * 检查 一个模块文件数据是否存在
		 * @param md
		 * @return 
		 * 
		 */		
		public function ModuleDataHave(md:ModuleData):Boolean{
			var indexTem:Number=moduleData.seachOne(md.url,ModuleData.URL);
			if(indexTem!=-1){
				return true;
			}
			return false;
		}
		/**
		 * 清除一个模块文件数据 
		 * @param swfname 注：不用包括".swf"
		 * 
		 */		
		public function ModuleDataClear(swfname:String):void{
			var indexTem:Number=moduleData.seachOne(swfname,ModuleData.URL,true);
		}
		/**
		 * @private
		 * 监听加载事件
		 * 
		 * @param p_info	加载对象的LoaderInfo
		 */
		private function initLoadEvent(p_info:LoaderInfo) : void
		{
			p_info.addEventListener(ProgressEvent.PROGRESS, this.onProgress);
			p_info.addEventListener(Event.COMPLETE, this.onComplete);
			p_info.addEventListener(IOErrorEvent.IO_ERROR, this.onError);
			p_info.addEventListener(SecurityErrorEvent.SECURITY_ERROR, this.onError);
		}
		/**
		 * @private
		 * 移除加载事件
		 * 
		 * @param p_info	加载对象的LoaderInfo
		 */
		private function removeLoadEvent(p_info : LoaderInfo) : void
		{
			p_info.removeEventListener(Event.COMPLETE, this.onComplete);
			p_info.removeEventListener(ProgressEvent.PROGRESS, this.onProgress);
			p_info.removeEventListener(IOErrorEvent.IO_ERROR, this.onError);
			p_info.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, this.onError);
		}
		/* 加载事件 */		
		private function onComplete(p_e : Event) : void
		{
			if(isLoadedLib<2){
				isLoadedLib++;
			}
			//
			var info : LoaderInfo = p_e.currentTarget as LoaderInfo;
			this.removeLoadEvent(info);
			//是否加载完库
			//this.removeLoadBar();
			//trace("isLoadMain:::"+isLoadMain);
			if(!isLoadMain){
				//加载下一个库
				debug("加载完成一个库",1);
				if(this.loadBar!=null){
					if(this.loadBar.isLoadCompleteDo()) {
						loadBar.setLoadCompleteDo(function():void{
							removeLoadBar();
							//两个库都加载完了,下一步是直接运行main
							if(isLoadedLib==2) isLoadMain=true;
							if(isLoadMain){
								debug("正式开始  main()",1);
								removeLoadBar();
								loadModuleComplete(2,info);
							}else{
								loadModuleComplete(1,info);
							}
						});
					}else{
						//注：和上面代码是一样的
						removeLoadBar();
						//两个库都加载完了,下一步是直接运行main
						if(isLoadedLib==2) isLoadMain=true;
						if(isLoadMain){
							debug("正式开始  main()",1);
							removeLoadBar();
							loadModuleComplete(2,info);
						}else{
							loadModuleComplete(1,info);
						}
					}
					//
					//
				}
			}else{
				//如果loadLibCompelet为null说明是加的画面,不然就是加载的是库文件,
				if(loadLibCompelet==null){
					if(!(info.content is ModuleBase)){
						throw new Error("加载的画面swf必须是继承CutLoad.ModuleBase!!");
					}
					//加载模板文件 
					//debug("加载完模板文件",1);
					if(this.loadBar!=null){
						if(this.loadBar.isLoadCompleteDo()) {
							loadBar.setLoadCompleteDo(function():void{
								removeLoadBar();
								loadModuleComplete(3,info);
							});
						}else{
							//注：和上面代码是一样的
							removeLoadBar();
							loadModuleComplete(3,info);
						}
					}
				}else{
					//加载库文件
					//debug("加载完程序中库文件",1);
					if(this.loadBar!=null){
						if(this.loadBar.isLoadCompleteDo()) {
							loadBar.setLoadCompleteDo(function():void{
								removeLoadBar();
								loadModuleComplete(4,info);
							});
						}else{
							//注：和上面代码是一样的
							removeLoadBar();
							loadModuleComplete(4,info);
						}
					}
					//
				}
			}
		}
		//加载模块完成后做的处理
		private function loadModuleComplete(type:uint,info:LoaderInfo):void{
			switch(type){
				case 1:
					//加载下一个库
					load(arrLibList[arrLibListIndex++],arrLibList[arrLibListIndex++], 1)
					
					break;
				case 2:
					//正试开始
					this.setLayerChildIndex_allTop();
					this.main();
					break;
				case 3:
					//加载模板文件
					currentModule=info.content as ModuleBase;
					debug("cutload 设置当前模块停在第一帧",2);
					currentModule.initData(this.currentModuleData);
					spFrameParent.addChild(currentModule);
					//当前焦点
					this.stage.focus=currentModule;
					funLoadModuleSwfCompt();
					set_containerAlign_currentModule();
					break;
				case 4:
					//加载一个库文件完成时。
					try{
						loadLibCompelet(info.content);
					}catch(e:ArgumentError){
						loadLibCompelet();
					}
					//只运行一次，然后设置为null
					loadLibCompelet=null;
					break;
			}
			
		}
		private function onProgress(p_e:ProgressEvent) : void
		{
			//trace("onProgress");
			if(loadBar!=null){
				loadBar.setValue(p_e.bytesLoaded/p_e.bytesTotal,loadbarTalkYou);
			}
		}
		private function onError(p_e : Event) : void
		{
			var strTem123:String="加载 \""+nowLoadSwfName+"\"文件 失败！"
			//if(!isNotUseUi) this.alert("错误!",strTem123);
			debug(strTem123,1)
			reLoad()
			//如果加载错误，继续尝试加载
		}
		//改变尺寸---------------------------------------------------------------------------------------		
		/**
		 * 添加需要当画面尺寸发生变化时要调用的元件 
		 * @param base
		 * @param resizeWH 尺寸改变时：改变该元件的宽高情况：0改变宽和高,1只改变宽,2只改变高
		 * 
		 */		
		public function addResize(base:Base,resizeWH:Number=0):void{
			if(resizeWH!=0&&resizeWH!=1&&resizeWH!=1) throw new Error("参数：resizeWH，只能是以下几个值:0改变宽和高,1只改变宽,2只改变高");
			arrResize.push({base:base,t:resizeWH});
		}
		/**
		 * 设置当场景尺寸发生改变时要调用的方法 
		 * @param fun 格式:function();
		 * 
		 */		
		public function setFunResizeDo(fun:Function):void{
			funResizeDo=fun;
		}
		private function funResize(e:Event):void{
			LoadBarModuleAppResize(this.getShowWidth(),this.getShowHeight(),loadBar);
			if(isAutoResizeWH) update();
		}
		/**
		 * 取消当场景尺寸发生改变时自行调用,CutLoad.setWH()
		 * @param isOk
		 * 
		 */		
		public function set autoResizeWH(isOk:Boolean):void{
			isAutoResizeWH=isOk;
		}
		/**
		 * 设置场景尺寸发生改变时,如果高宽小于这个值就不再处理全局对齐
		 * @param minW 最小宽
		 * @param minH 最小高
		 * 
		 */		
		public function setResizeMinWH(minW:Number,minH:Number):void{
			this.minStageWidth=minW;
			this.minStageHeight=minH;
		}
		/**
		 * 设置场景尺寸发生改变时，超过这个值要做的处理
		 * @param maxW 最大宽度 如果不为0，当场景的宽度大于这个值时，会水平居中。
		 * @param maxH 最大高度 如果不为0，当场景的高度大于这个值时，会垂直居中。
		 * 
		 */		
		public function setResizeMaxWH(maxW:Number=0,maxH:Number=0):void{
			this.maxStageWidth=maxW;
			this.maxStageHeight=maxH;
		}
		//同步currentModule的坐标等于containerAlign的坐标，主要是用于，当使用setResizeMaxWH 个方法后。
		private function set_containerAlign_currentModule():void{
			if(this.currentModule!=null){
				this.currentModule.x=containerAlign.x;
				this.currentModule.y=containerAlign.y;
			}
		}
		/**
		 * 最小宽度，提示：获得 场景尺寸发生改变时，如果宽度小于这个值就不再处理全局对齐
		 * @return 
		 * 
		 */		
		public function get resizeMinWidth():Number{
			return minStageWidth
		}
		/**
		 * 最小高度，提示：获得 场景尺寸发生改变时，如果高度小于这个值就不再处理全局对齐
		 * @return 
		 * 
		 */		
		public function get resizeMinHeight():Number{
			return minStageHeight
		}
		/**
		 * 主画面尺寸，此方法一般为程序当场景尺寸发生改变时自行调用。 注：如果想取消自行调用，请调用CutLoad.autoResizeWH=true/false取消
		 * @param w
		 * @param h
		 * 
		 */		
		public function setWH(w:Number=0, h:Number=0):void{
			if(w<this.minStageWidth) w=this.minStageWidth;
			if(h<this.minStageHeight) h=this.minStageHeight;
			//如果设置了最大宽高的话,超过这个数，中心居中，或顶居中
			var containerAlign_w:Number=w;
			var containerAlign_h:Number=h;
			//trace("www:"+w+" this.maxStageWidth "+this.maxStageWidth);
			//trace("hhh:"+h+" this.maxStageHeight "+this.maxStageHeight)
			if(maxStageWidth>0){
				if(w>this.maxStageWidth){
					containerAlign_w=this.maxStageWidth;
					containerAlign.x=(this.getShowWidth()-containerAlign_w)/2;
				}else{
					containerAlign.x=0;
				}
			}
			if(maxStageHeight>0){
				if(h>this.maxStageHeight){
					containerAlign_h=this.maxStageHeight;
					containerAlign.y=(this.getShowHeight()-containerAlign_h)/2
				}else{
					containerAlign.y=0;
				}
			}
			//如果设置了最小宽高，
			if(this.minStageWidth>0){
				if(w<this.minStageWidth){
					containerAlign_w=minStageWidth;
				}
			}
			if(this.minStageHeight>0){
				if(h<this.minStageHeight){
					containerAlign_h=minStageHeight;
				}
			}
			containerAlign.setWH(containerAlign_w,containerAlign_h);
			//trace("containerAlign.setWH  "+containerAlign_w+","+containerAlign_h);
			set_containerAlign_currentModule();
			//
			//
			//
			spBak.setWH(w,h);
			Popup.setWH(w,h);
			//
			var obj:Object;
			var baseTem:Base;
			for(var i:Number=0;i<arrResize.length;i++){
				obj=arrResize[i];
				baseTem=obj.base;
				if(obj.t==1){
					baseTem.setWH(w,baseTem.getShowWidth());
				}else if(obj.t==2){
					baseTem.setWH(baseTem.getShowWidth(),h);
				}else{
					baseTem.setWH(w,h);
				}
			}
			//更新
			if(tipManagement!=null) this.tipManagement.update();
			//
			//
			if(funResizeDo!=null){
				funResizeDo();
			}
			if(currentModule!=null) currentModule.setWH(this.getShowWidth(),this.getShowHeight());
		}
		//改变尺寸---------------------------------------------------------------------------------------
		/**
		 * 刷新画 面
		 * 
		 */		
		private function update():void{
			setWH(getShowWidth(),getShowHeight());
		}
		/**
		 * 刷新画 面
		 * 注：调用 update()
		 */
		public function refreshLayout():void{
			update();
		}
		/**
		 * 添加全局对齐的元素,在画面中:0居中,1左上,2上中,3右上,4右中,5右下,6下中,7左下,8左中
		 * @param base 要添加对齐的元素
		 * @param t 对齐类型:0居中,1左上,2上中,3右上,4右中,5右下,6下中,7左下,8左中
		 * 
		 */		
		public function addAlign(base:Base,t:Number=0):void{
			containerAlign.append(base,true,{t:t});
		}
		/**
		 * 清除一个全局对齐元素
		 * @param base 
		 * 
		 */		
		public function delAlign(base:Base):void{
			containerAlign.delChild(base);
		}
		//弹出-------------------------------------------------------------------------------------------------------------
		//等待
		private var waitAlert:CWait
		//
		/**
		 * 显示等待画面 
		 * @param contend 内容
		 * @param tile 标题
		 * @param t 弹出框出现在相对位置，默认为0:居中，详细值：0居中,1左上,2上中,3右上,4右中,5右下,6下中,7左下,8左中,注：布局是使用：CutLoad.cookies.LayoutTable来实现的
		 * 
		 */			
		public function wait(contend:String="",tile:String="请等待",t:Number=0,w:Number=0,h:Number=0):CWait{
			if(waitAlert==null){
				waitAlert=new CWait();
				waitAlert.init(contend,tile);
			}else{
				waitAlert.setTitle(tile);
				waitAlert.setContent(contend);
			}
			waitAlert.setWH(w,h);
			Popup.popup(waitAlert,t);
			return waitAlert;
		}
		/**
		 * 关闭等待画面
		 * 
		 */		
		public function closeWait():Boolean{
			if(waitAlert!=null){
				Popup.remove(waitAlert);
				waitAlert=null
				return true;
			}
			return false
		}
		/**
		 * 获得等待画面引用 
		 * @return 
		 * 
		 */		
		public function getWaitAlert():CWait{
			return waitAlert;
		}
		//确定
		private var alert_ok_sendFun:Function;
		/**
		 * 弹出框
		 * @param tile 标题
		 * @param contend 内容
		 * @param btnOkLable 弹出框“ok”按钮换成其它名字
		 * @param fun 点击弹出框“ok”按钮时调用的方法。可以为null,方法的格式：fun();
		 * @param t 弹出框出现在相对位置，默认为0:居中，详细值：0居中,1左上,2上中,3右上,4右中,5右下,6下中,7左下,8左中,注：布局是使用：CutLoad.cookies.LayoutTable来实现的
		 * 
		 */		
		public function alert(tile:String="",contend:String="",btnOkLable:String="OK",fun:Function=null,t:Number=0):CAlert{
			alert_ok_sendFun=fun;
			var cA:CAlert=new CAlert();
			cA.init(tile,contend,[btnOkLable],alert_click);
			Popup.popup(cA,t);
			return cA;
		}
		//弹出框确定时调用的函数
		private function alert_click(id:Number=0):void{
			this.Popup.removeTop();
			if(alert_ok_sendFun!=null) alert_ok_sendFun();
		}
		//弹出框,是或否
		private var confirm_ok_no_sendFun:Function;
		/**
		 * 选择弹出窗口
		 * @param tile 标题
		 * @param contend 内容
		 * @param btnOkLable 弹出框“ok”按钮换成其它名字
		 * @param btnNoLable 弹出框“no”按钮换成其它名字
		 * @param fun 点击ok或no需要调用的方法，默认为null,格式：fun(是否点击了ok:Boolean)
		 * @param t 弹出框出现在相对位置，默认为0:居中，详细值：0居中,1左上,2上中,3右上,4右中,5右下,6下中,7左下,8左中,注：布局是使用：CutLoad.cookies.LayoutTable来实现的
		 * @return 
		 */		
		public function confirm(tile:String="",contend:String="",btnOkLable:String="OK",btnNoLable:String="NO",fun:Function=null,t:Number=0):CAlert{
			confirm_ok_no_sendFun=fun;
			var cA:CAlert=new CAlert();
			cA.init(tile,contend,[btnOkLable,btnNoLable],confirm_click);
			Popup.popup(cA,t);
			return cA
		}
		//
		private function confirm_click(id:Number):void{
			var isOk:Boolean=false
			if(id==0) isOk=true;
			this.Popup.removeTop();
			if(confirm_ok_no_sendFun!=null) confirm_ok_no_sendFun(isOk)
		}
		/**
		 * 获得画面宽度,如果设置最大或最小画面宽度。会进行比较，如果大于或小于设置的，会返回最大或最小画面宽度
		 * @return 
		 * 
		 */		
		public function getShowWidthComparisonMaxMin():Number{
			var ww:Number=this.getShowWidth();
			if(this.maxStageWidth!=0){
				if(ww>this.maxStageWidth) ww=this.maxStageWidth;
				if(ww<this.minStageWidth) ww=this.minStageWidth;
			}
			return ww;
		}
		/**
		 * 获得画面高度,如果设置最大或最小画面高度。会进行比较，如果大于或小于设置的，会返回最大或最小画面高度 
		 * @return 
		 * 
		 */		
		public function getShowHeightComparisonMaxMin():Number{
			var hh:Number=this.getShowHeight();
			if(this.maxStageHeight!=0){
				if(hh>this.maxStageHeight) hh=this.maxStageHeight;
				if(hh<this.minStageWidth) hh=this.minStageWidth;
			}
			return hh;
		}
		//覆盖
		/**
		 * 获得画面宽度
		 * @return
		 * 
		 */		
		public function getShowWidth():Number{
			if(stage==null) return 0
			return stage.stageWidth;
		}
		/**
		 * 获得画面高度 
		 * @return 
		 * 
		 */		
		public function getShowHeight():Number{
			if(stage==null) return 0;
			return stage.stageHeight;
		}
		/**
		 * 消除自已
		 * 
		 */		
		public function killMe():void{
			if(this.parent!=null) this.parent.removeChild(this);
		}
	}
}